package com.wicket.okrcomponent.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrcomponent.biz.service.dto.req.*;
import com.wicket.okrcomponent.biz.service.dto.res.*;
import com.wicket.okrcomponent.common.exception.BizException;
import com.wicket.okrcomponent.common.util.CommonFunctionHelper;
import com.wicket.okrcomponent.common.util.RedisUtil;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrcomponent.common.exception.Assert;
import com.wicket.okrcomponent.biz.service.BusinessAtomService;
import java.util.ArrayList;
import java.util.Collections;
import com.wicket.okrcomponent.biz.service.NetDiskService;
import com.wicket.okrcomponent.biz.service.InterfaceModeService;
import com.wicket.okrcomponent.biz.service.TemplateEngineService;
import com.wicket.okrcomponent.biz.service.nb.NbResourceFile;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrcomponent.biz.service.ConfSchemeService;
import com.wicket.okrcomponent.biz.service.dto.common.ItemDto;
import com.wicket.okrcomponent.biz.service.dto.common.OutputBusinessDataDto;
import com.wicket.okrcomponent.biz.service.IntelligentCommunicationService;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class ResourceFileServiceImpl
  implements com.wicket.okrcomponent.biz.service.ResourceFileService {

  @Resource
  private RedisUtil redisUtil;
@Resource
  private BusinessAtomService businessAtomService;
//@Resource
 //private MOmsResourceFileService mOmsResourceFileService;
//@Resource
 //private undefinedService undefinedService;
@Resource
  private NetDiskService netDiskService;
@Resource
  private InterfaceModeService interfaceModeService;
@Resource
  private TemplateEngineService templateEngineService;
//@Resource
 //private MSpecMethordTableService mSpecMethordTableService;
@Resource
  private NbResourceFile nbResourceFile;
@Resource
  private ConfSchemeService confSchemeService;
//@Resource
 //private MCustomFields4Service mCustomFields4Service;
@Resource
  private IntelligentCommunicationService intelligentCommunicationService;
//@Resource
 //private MCustomFields5Service mCustomFields5Service;
//@Resource
 //private MCustomFields6Service mCustomFields6Service;
/**
   * D2删除REDIS物理文件记录(redis)(公共)[10407]
   * gen by moon at 12/4/2024, 7:23:28 AM
   */
  @Trace(operationName = "D2删除REDIS物理文件记录(redis)(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public DeletePhyFileRedisRecordComRespDto deletePhyFileRedisRecordCom(DeletePhyFileRedisRecordComReqDto reqDto){
    
      
      //步骤0: D2删除redis业务数据对象(业务原子) - deleteRedisBusinessDataSetCom
     DeleteRedisBusinessDataSetComRespDto deleteRedisBusinessDataSetComRespDto = null;
    DeleteRedisBusinessDataSetComReqDto deleteRedisBusinessDataSetComReqDto=new DeleteRedisBusinessDataSetComReqDto();
  deleteRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("物理文件记录");//sourceId:2029909_1
deleteRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:2029911_1
deleteRedisBusinessDataSetComReqDto.setCustomField1("physicalFilePath");//CUSTOM_CONVENTION//sourceId:2029912_1
if(reqDto!=null){
      deleteRedisBusinessDataSetComReqDto.setBusinessDataObject(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2029910_1
deleteRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getPhyFilePath());//SimpleFieldAssign//sourceId:2029913_1
    }
  
    /*D2删除redis业务数据对象(业务原子)[9717]   */
    Assert.isNull(deleteRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D2删除REDIS物理文件记录(redis)(公共)-D2删除redis业务数据对象(业务原子)-业务数据对象不能为空",false);
Assert.isNull(deleteRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D2删除REDIS物理文件记录(redis)(公共)-D2删除redis业务数据对象(业务原子)-Redis数据对象目录不能为空",false);
Assert.isNull(deleteRedisBusinessDataSetComReqDto.getIsDataList(),"D2删除REDIS物理文件记录(redis)(公共)-D2删除redis业务数据对象(业务原子)-是否是数据集对象不能为空",false);
      deleteRedisBusinessDataSetComRespDto = businessAtomService.deleteRedisBusinessDataSetCom(deleteRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;
      
      
      
    
DeletePhyFileRedisRecordComRespDto retData = new DeletePhyFileRedisRecordComRespDto();
  
  

  
  
return retData;
  }
/**
   * D2新增物理文件路径记录到缓存(redis)(公共)[10406]
   * gen by moon at 12/6/2024, 10:01:55 PM
   */
  @Trace(operationName = "D2新增物理文件路径记录到缓存(redis)(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddPhyFileToRedisComRespDto addPhyFileToRedisCom(AddPhyFileToRedisComReqDto reqDto){
    
      
      //步骤0: D2-新增redis业务数据对象（业务原子） - addRedisBusinessDataSetCom
     AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
    AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto=new AddRedisBusinessDataSetComReqDto();
  addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("物理文件记录");//sourceId:2029877_1
addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:2029878_1
addRedisBusinessDataSetComReqDto.setCustomField1("physicalFilePath");//CUSTOM_CONVENTION//sourceId:2029879_1
addRedisBusinessDataSetComReqDto.setCustomField2("storageType");//CUSTOM_CONVENTION//sourceId:2029881_1
if(reqDto!=null){
      addRedisBusinessDataSetComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:2029876_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getPyhFilePath());//SimpleFieldAssign//sourceId:2029880_1
addRedisBusinessDataSetComReqDto.setCustomFieldValue2(reqDto.getUploadType());//SimpleFieldAssign//sourceId:2029882_1
    }
  
    /*D2-新增redis业务数据对象（业务原子）[8399]   */
    Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(),"D2新增物理文件路径记录到缓存(redis)(公共)-D2-新增redis业务数据对象（业务原子）-业务数据对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(),"D2新增物理文件路径记录到缓存(redis)(公共)-D2-新增redis业务数据对象（业务原子）-Redis数据对象目录不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(),"D2新增物理文件路径记录到缓存(redis)(公共)-D2-新增redis业务数据对象（业务原子）-是否是数据集对象不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(),"D2新增物理文件路径记录到缓存(redis)(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值1不能为空",false);
Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue2(),"D2新增物理文件路径记录到缓存(redis)(公共)-D2-新增redis业务数据对象（业务原子）-自定义字段值2不能为空",false);
      addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;
      
      
      
    
AddPhyFileToRedisComRespDto retData = new AddPhyFileToRedisComRespDto();
  
  

  
  
return retData;
  }
/**
   * D2循环生成资源文件相对路径并缓存相对路径(公共)[10413]
   * gen by moon at 12/8/2024, 3:23:18 AM
   */
  @Trace(operationName = "D2循环生成资源文件相对路径并缓存相对路径(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public LoopSetResourceFileComRespDto loopSetResourceFileCom(LoopSetResourceFileComReqDto reqDto){


      QueryMemorysBusinessDataListComRespDto queryMemorysBusinessDataListComRespDto_1 =null;
//virtualUsage D2查询上传类型  73708
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2034226_1_73708
queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:2034227_1_73708
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("UPLOAD_TYPE");//CUSTOM_CONVENTION//sourceId:2034228_1_73708
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:2034229_1_73708

    /*D2查询上传类型[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2查询上传类型-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2查询上传类型-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2查询上传类型-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2查询上传类型-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage M2-执行资源文件【循环开始】（特殊方法）  73629
      //ModelCode: circulationCollections
        for (String circulationCollectionsRes: reqDto.getResourceFileList()){

//virtualUsage D2执行上传文件名称转单字段(公共)  73683
      ImplementUploadFileNameToFieldComRespDto implementUploadFileNameToFieldComRespDto = null;
    ImplementUploadFileNameToFieldComReqDto implementUploadFileNameToFieldComReqDto=new ImplementUploadFileNameToFieldComReqDto();
  if(circulationCollectionsRes!=null){
      implementUploadFileNameToFieldComReqDto.setResourceFileName(circulationCollectionsRes);//SimpleFieldAssign//sourceId:2033732_1_73683
    }

    /*D2执行上传文件名称转单字段(公共)[10418]   */
    Assert.isNull(implementUploadFileNameToFieldComReqDto.getResourceFileName(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2执行上传文件名称转单字段(公共)-资源文件名称不能为空",false);
      implementUploadFileNameToFieldComRespDto = netDiskService.implementUploadFileNameToFieldCom(implementUploadFileNameToFieldComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D2将系统当前日期转换为字符串  73635
      ImplementDateFormatComRespDto implementDateFormatComRespDto = null;
    ImplementDateFormatComReqDto implementDateFormatComReqDto=new ImplementDateFormatComReqDto();
  implementDateFormatComReqDto.setComTimeField(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:2031571_1_73635
implementDateFormatComReqDto.setTimeFormatMode("yyyy");//CUSTOM_CONVENTION//sourceId:2031572_1_73635

    /*D2将系统当前日期转换为字符串[8203]   */
    Assert.isNull(implementDateFormatComReqDto.getComTimeField(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2将系统当前日期转换为字符串-通用时间字段不能为空",false);
Assert.isNull(implementDateFormatComReqDto.getTimeFormatMode(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2将系统当前日期转换为字符串-时间格式模式不能为空",false);
      implementDateFormatComRespDto = interfaceModeService.implementDateFormatCom(implementDateFormatComReqDto)/*vcase invoke isSameApp*/;



if((reqDto!= null&&  reqDto.getPlatformOrTenantDoc() !=null && reqDto.getPlatformOrTenantDoc().equals("PLATFORM"))) {
        //if(D2循环生成资源文件相对路径并缓存相对路径(公共).平台或租户文档 等于 平台)  73630

GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto = null;
    if(implementDateFormatComRespDto !=null){
          GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto=new GenerateSemanticInstanceStoryComReqDto();
  generateSemanticInstanceStoryComReqDto.setTemplateSemanticEngineCode("PLATFORM_DOCUMENT_RELATIVE_PATH");//CUSTOM_CONVENTION//sourceId:2031545_1_73632
generateSemanticInstanceStoryComReqDto.setFirstFieldName("platformOrTenantDoc");//CUSTOM_CONVENTION//sourceId:2031539_1_73632
generateSemanticInstanceStoryComReqDto.setSecondFieldName("docUseType");//CUSTOM_CONVENTION//sourceId:2031541_1_73632
generateSemanticInstanceStoryComReqDto.setThirdFieldName("comTxtField");//CUSTOM_CONVENTION//sourceId:2031543_1_73632
if(reqDto!=null){
      generateSemanticInstanceStoryComReqDto.setFirstFieldValue(reqDto.getPlatformOrTenantDoc());//SimpleFieldAssign//sourceId:2031540_1_73632
generateSemanticInstanceStoryComReqDto.setSecondFieldValue(reqDto.getDocUseType());//SimpleFieldAssign//sourceId:2031542_1_73632
    }
if(implementDateFormatComRespDto!=null){
      generateSemanticInstanceStoryComReqDto.setThirdFieldValue(implementDateFormatComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:2031544_1_73632
    }

    /*D2生成平台文档相对路径[8234]   */
    Assert.isNull(generateSemanticInstanceStoryComReqDto.getTemplateSemanticEngineCode(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成平台文档相对路径-模板引擎标识不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldName(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成平台文档相对路径-第一个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldValue(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成平台文档相对路径-第一个字段字段值不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto.getSecondFieldName(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成平台文档相对路径-第二个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto.getSecondFieldValue(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成平台文档相对路径-第二个字段字段值不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto.getThirdFieldName(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成平台文档相对路径-第三个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto.getThirdFieldValue(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成平台文档相对路径-第三个字段字段值不能为空",false);
      generateSemanticInstanceStoryComRespDto = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto)/*vcase invoke isSameApp*/;



           }
GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto_2 = null;
    if(generateSemanticInstanceStoryComRespDto !=null&&implementUploadFileNameToFieldComRespDto !=null){
          GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto_1=new GenerateSemanticInstanceStoryComReqDto();
  generateSemanticInstanceStoryComReqDto_1.setTemplateSemanticEngineCode("CONCAT_FILE_PATH");//CUSTOM_CONVENTION//sourceId:2033692_1_73681
generateSemanticInstanceStoryComReqDto_1.setFirstFieldName("resourceFileRelaPath");//CUSTOM_CONVENTION//sourceId:2033686_1_73681
generateSemanticInstanceStoryComReqDto_1.setSecondFieldName("phyFileUuid");//CUSTOM_CONVENTION//sourceId:2033688_1_73681
generateSemanticInstanceStoryComReqDto_1.setThirdFieldName("resourceFileExtension");//CUSTOM_CONVENTION//sourceId:2033690_1_73681
if(generateSemanticInstanceStoryComRespDto!=null){
      generateSemanticInstanceStoryComReqDto_1.setFirstFieldValue(generateSemanticInstanceStoryComRespDto.getObjectName());//SimpleFieldAssign//sourceId:2033687_1_73681
    }
if(implementUploadFileNameToFieldComRespDto!=null){
      generateSemanticInstanceStoryComReqDto_1.setSecondFieldValue(implementUploadFileNameToFieldComRespDto.getPhyFileUuid());//SimpleFieldAssign//sourceId:2033689_1_73681
generateSemanticInstanceStoryComReqDto_1.setThirdFieldValue(implementUploadFileNameToFieldComRespDto.getResourceFileExtension());//SimpleFieldAssign//sourceId:2033691_1_73681
    }

    /*D2拼接文件路径[8234]   */
    Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getTemplateSemanticEngineCode(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-模板引擎标识不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getFirstFieldName(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第一个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getFirstFieldValue(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第一个字段字段值不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getSecondFieldName(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第二个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getSecondFieldValue(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第二个字段字段值不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getThirdFieldName(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第三个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getThirdFieldValue(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第三个字段字段值不能为空",false);
      generateSemanticInstanceStoryComRespDto_2 = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto_1)/*vcase invoke isSameApp*/;



           }
AddMemoryBusiness2DataComRespDto addMemoryBusiness2DataComRespDto = null;
    if(generateSemanticInstanceStoryComRespDto_2 !=null){
          AddMemoryBusiness2DataComReqDto addMemoryBusiness2DataComReqDto=new AddMemoryBusiness2DataComReqDto();
  addMemoryBusiness2DataComReqDto.setIsDataList("TRUE");//sourceId:2033683_1_73679
addMemoryBusiness2DataComReqDto.setCustomField1("resourceFileRelaPath");//CUSTOM_CONVENTION//sourceId:2033684_1_73679
if(reqDto!=null){
      addMemoryBusiness2DataComReqDto.setBusinessDataObject(reqDto.getPlatformOrTenantDoc());//SimpleFieldAssign//sourceId:2033682_1_73679
      addMemoryBusiness2DataComReqDto.setDataObjectBatchCode(reqDto.getDocUseType());//SimpleFieldAssign//sourceId:2033681_1_73679
    }
if(generateSemanticInstanceStoryComRespDto_2!=null){
      addMemoryBusiness2DataComReqDto.setCustomFieldValue1(generateSemanticInstanceStoryComRespDto_2.getObjectName());//SimpleFieldAssign//sourceId:2033685_1_73679
    }

    /*D2新增内存业务数据(业务原子)[9751]   */
    Assert.isNull(addMemoryBusiness2DataComReqDto.getBusinessDataObject(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-业务数据对象不能为空",false);
    Assert.isNull(addMemoryBusiness2DataComReqDto.getDataObjectBatchCode(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-数据对象批次标识不能为空",false);
Assert.isNull(addMemoryBusiness2DataComReqDto.getIsDataList(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-是否是数据集对象不能为空",false);
Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomField1(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-自定义字段1不能为空",false);
Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomFieldValue1(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-自定义字段值1不能为空",false);
      addMemoryBusiness2DataComRespDto = businessAtomService.addMemoryBusiness2DataCom(addMemoryBusiness2DataComReqDto)/*vcase invoke isSameApp*/;



           }
AddPhyFileToRedisComRespDto addPhyFileToRedisComRespDto = null;
    if(generateSemanticInstanceStoryComRespDto !=null&&queryConfItemMatchAnswerDetailComRespDto !=null){
          AddPhyFileToRedisComReqDto addPhyFileToRedisComReqDto=new AddPhyFileToRedisComReqDto();
  if(reqDto!=null){
      addPhyFileToRedisComReqDto.setBusinessDataObject(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2031580_1_73636
    }
if(generateSemanticInstanceStoryComRespDto!=null){
      addPhyFileToRedisComReqDto.setPyhFilePath(generateSemanticInstanceStoryComRespDto.getObjectName());//SimpleFieldAssign//sourceId:2031581_1_73636
    }
        addPhyFileToRedisComReqDto.setUploadType(queryConfItemMatchAnswerDetailComRespDto.getEndValue());

    /*D2新增物理文件路径记录到缓存(redis)(公共)[10406]   */
    Assert.isNull(addPhyFileToRedisComReqDto.getBusinessDataObject(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增物理文件路径记录到缓存(redis)(公共)-业务数据对象不能为空",false);
Assert.isNull(addPhyFileToRedisComReqDto.getUploadType(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增物理文件路径记录到缓存(redis)(公共)-自定义字段值1不能为空",false);
Assert.isNull(addPhyFileToRedisComReqDto.getPyhFilePath(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增物理文件路径记录到缓存(redis)(公共)-自定义字段值2不能为空",false);
      addPhyFileToRedisComRespDto = addPhyFileToRedisCom(addPhyFileToRedisComReqDto)/*vcase invoke 同服务,同domain*/;



           }
      }
else if((reqDto!= null&&  reqDto.getPlatformOrTenantDoc() !=null && reqDto.getPlatformOrTenantDoc().equals("SPACE"))){
       //elseif(D2循环生成资源文件相对路径并缓存相对路径(公共).平台或租户文档 等于 租户)  73631

GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto_4 = null;
    if(implementDateFormatComRespDto !=null){
          GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto_2=new GenerateSemanticInstanceStoryComReqDto();
  generateSemanticInstanceStoryComReqDto_2.setTemplateSemanticEngineCode("TENANT_DOCUMENT_RELATIVE_PATH");//CUSTOM_CONVENTION//sourceId:2031559_1_73633
generateSemanticInstanceStoryComReqDto_2.setFirstFieldName("platformOrTenantDoc");//CUSTOM_CONVENTION//sourceId:2031553_1_73633
generateSemanticInstanceStoryComReqDto_2.setSecondFieldName("spaceId");//CUSTOM_CONVENTION//sourceId:2031555_1_73633
generateSemanticInstanceStoryComReqDto_2.setThirdFieldName("userId");//CUSTOM_CONVENTION//sourceId:2031557_1_73633
generateSemanticInstanceStoryComReqDto_2.setFourFieldName("docUseType");//CUSTOM_CONVENTION//sourceId:2031561_1_73633
generateSemanticInstanceStoryComReqDto_2.setFiveFieldName("comTxtField");//CUSTOM_CONVENTION//sourceId:2031563_1_73633
if(reqDto!=null){
      generateSemanticInstanceStoryComReqDto_2.setFirstFieldValue(reqDto.getPlatformOrTenantDoc());//SimpleFieldAssign//sourceId:2031554_1_73633
generateSemanticInstanceStoryComReqDto_2.setSecondFieldValue(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2031556_1_73633
generateSemanticInstanceStoryComReqDto_2.setThirdFieldValue(reqDto.getUserId());//SimpleFieldAssign//sourceId:2031558_1_73633
generateSemanticInstanceStoryComReqDto_2.setFourFieldValue(reqDto.getDocUseType());//SimpleFieldAssign//sourceId:2031562_1_73633
    }
if(implementDateFormatComRespDto!=null){
      generateSemanticInstanceStoryComReqDto_2.setFiveFieldValue(implementDateFormatComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:2031564_1_73633
    }

    /*D2生成租户文档相对路径[8234]   */
    Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getTemplateSemanticEngineCode(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-模板引擎标识不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getFirstFieldName(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第一个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getFirstFieldValue(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第一个字段字段值不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getSecondFieldName(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第二个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getSecondFieldValue(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第二个字段字段值不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getThirdFieldName(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第三个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getThirdFieldValue(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第三个字段字段值不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getFourFieldName(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第四个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getFourFieldValue(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第四个字段字段值不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getFiveFieldName(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第五个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getFiveFieldValue(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2生成租户文档相对路径-第五个字段字段值不能为空",false);
      generateSemanticInstanceStoryComRespDto_4 = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto_2)/*vcase invoke isSameApp*/;



           }
GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto_6 = null;
    if(generateSemanticInstanceStoryComRespDto_4 !=null&&implementUploadFileNameToFieldComRespDto !=null){
          GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto_3=new GenerateSemanticInstanceStoryComReqDto();
  generateSemanticInstanceStoryComReqDto_3.setTemplateSemanticEngineCode("CONCAT_FILE_PATH");//CUSTOM_CONVENTION//sourceId:2033692_1_73682
generateSemanticInstanceStoryComReqDto_3.setFirstFieldName("resourceFileRelaPath");//CUSTOM_CONVENTION//sourceId:2033686_1_73682
generateSemanticInstanceStoryComReqDto_3.setSecondFieldName("phyFileUuid");//CUSTOM_CONVENTION//sourceId:2033688_1_73682
generateSemanticInstanceStoryComReqDto_3.setThirdFieldName("resourceFileExtension");//CUSTOM_CONVENTION//sourceId:2033690_1_73682
if(generateSemanticInstanceStoryComRespDto_4!=null){
      generateSemanticInstanceStoryComReqDto_3.setFirstFieldValue(generateSemanticInstanceStoryComRespDto_4.getObjectName());//SimpleFieldAssign//sourceId:2033687_1_73682
    }
if(implementUploadFileNameToFieldComRespDto!=null){
      generateSemanticInstanceStoryComReqDto_3.setSecondFieldValue(implementUploadFileNameToFieldComRespDto.getPhyFileUuid());//SimpleFieldAssign//sourceId:2033689_1_73682
generateSemanticInstanceStoryComReqDto_3.setThirdFieldValue(implementUploadFileNameToFieldComRespDto.getResourceFileExtension());//SimpleFieldAssign//sourceId:2033691_1_73682
    }

    /*D2拼接文件路径[8234]   */
    Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getTemplateSemanticEngineCode(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-模板引擎标识不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getFirstFieldName(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第一个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getFirstFieldValue(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第一个字段字段值不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getSecondFieldName(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第二个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getSecondFieldValue(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第二个字段字段值不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getThirdFieldName(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第三个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getThirdFieldValue(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2拼接文件路径-第三个字段字段值不能为空",false);
      generateSemanticInstanceStoryComRespDto_6 = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto_3)/*vcase invoke isSameApp*/;



           }
AddMemoryBusiness2DataComRespDto addMemoryBusiness2DataComRespDto_1 = null;
    if(generateSemanticInstanceStoryComRespDto_6 !=null){
          AddMemoryBusiness2DataComReqDto addMemoryBusiness2DataComReqDto_1=new AddMemoryBusiness2DataComReqDto();
  addMemoryBusiness2DataComReqDto_1.setIsDataList("TRUE");//sourceId:2033683_1_73680
addMemoryBusiness2DataComReqDto_1.setCustomField1("resourceFileRelaPath");//CUSTOM_CONVENTION//sourceId:2033684_1_73680
if(reqDto!=null){
      addMemoryBusiness2DataComReqDto_1.setBusinessDataObject(reqDto.getPlatformOrTenantDoc());//SimpleFieldAssign//sourceId:2033682_1_73680
addMemoryBusiness2DataComReqDto_1.setDataObjectBatchCode(reqDto.getDocUseType());//SimpleFieldAssign//sourceId:2033681_1_73680
    }
if(generateSemanticInstanceStoryComRespDto_6!=null){
      addMemoryBusiness2DataComReqDto_1.setCustomFieldValue1(generateSemanticInstanceStoryComRespDto_6.getObjectName());//SimpleFieldAssign//sourceId:2033685_1_73680
    }

    /*D2新增内存业务数据(业务原子)[9751]   */
    Assert.isNull(addMemoryBusiness2DataComReqDto_1.getBusinessDataObject(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-业务数据对象不能为空",false);
    Assert.isNull(addMemoryBusiness2DataComReqDto_1.getDataObjectBatchCode(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-数据对象批次标识不能为空",false);
Assert.isNull(addMemoryBusiness2DataComReqDto_1.getIsDataList(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-是否是数据集对象不能为空",false);
Assert.isNull(addMemoryBusiness2DataComReqDto_1.getCustomField1(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-自定义字段1不能为空",false);
Assert.isNull(addMemoryBusiness2DataComReqDto_1.getCustomFieldValue1(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增内存业务数据(业务原子)-自定义字段值1不能为空",false);
      addMemoryBusiness2DataComRespDto_1 = businessAtomService.addMemoryBusiness2DataCom(addMemoryBusiness2DataComReqDto_1)/*vcase invoke isSameApp*/;



           }
AddPhyFileToRedisComRespDto addPhyFileToRedisComRespDto_1 = null;
    if(generateSemanticInstanceStoryComRespDto_4 !=null&&queryConfItemMatchAnswerDetailComRespDto !=null){
          AddPhyFileToRedisComReqDto addPhyFileToRedisComReqDto_1=new AddPhyFileToRedisComReqDto();
  if(reqDto!=null){
      addPhyFileToRedisComReqDto_1.setBusinessDataObject(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2031580_1_73637
    }
if(generateSemanticInstanceStoryComRespDto_4!=null){
      addPhyFileToRedisComReqDto_1.setPyhFilePath(generateSemanticInstanceStoryComRespDto_4.getObjectName());//SimpleFieldAssign//sourceId:2031581_1_73637
    }
        addPhyFileToRedisComReqDto_1.setUploadType(queryConfItemMatchAnswerDetailComRespDto.getEndValue());

    /*D2新增物理文件路径记录到缓存(redis)(公共)[10406]   */
    Assert.isNull(addPhyFileToRedisComReqDto_1.getBusinessDataObject(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增物理文件路径记录到缓存(redis)(公共)-业务数据对象不能为空",false);
Assert.isNull(addPhyFileToRedisComReqDto_1.getPyhFilePath(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2新增物理文件路径记录到缓存(redis)(公共)-自定义字段值2不能为空",false);
      addPhyFileToRedisComRespDto_1 = addPhyFileToRedisCom(addPhyFileToRedisComReqDto_1)/*vcase invoke 同服务,同domain*/;



           }
    }
//virtualUsage M2-执行【循环结束】（特殊方法）  73634
      //ModelCode: circulationEnd
        }

//virtualUsage D2取出文件路径数据集  73697
      QueryMemorysBusinessDataListComRespDto queryMemorysBusinessDataListComRespDto = null;
    QueryMemorysBusinessDataListComReqDto queryMemorysBusinessDataListComReqDto=new QueryMemorysBusinessDataListComReqDto();
  queryMemorysBusinessDataListComReqDto.setCustomField1("resourceFileRelaPath");//CUSTOM_CONVENTION//sourceId:2034071_1_73697
if(reqDto!=null){
      queryMemorysBusinessDataListComReqDto.setBusinessDataObject(reqDto.getPlatformOrTenantDoc());//SimpleFieldAssign//sourceId:2034060_1_73697
queryMemorysBusinessDataListComReqDto.setDataObjectBatchCode(reqDto.getDocUseType());//SimpleFieldAssign//sourceId:2034062_1_73697
    }

    /*D2取出文件路径数据集[10425]   */
    Assert.isNull(queryMemorysBusinessDataListComReqDto.getBusinessDataObject(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2取出文件路径数据集-业务数据对象不能为空",false);
Assert.isNull(queryMemorysBusinessDataListComReqDto.getDataObjectBatchCode(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2取出文件路径数据集-数据对象批次标识不能为空",false);
Assert.isNull(queryMemorysBusinessDataListComReqDto.getCustomField1(),"D2循环生成资源文件相对路径并缓存相对路径(公共)-D2取出文件路径数据集-自定义字段1不能为空",false);
      queryMemorysBusinessDataListComRespDto = interfaceModeService.queryMemorysBusinessDataListCom(queryMemorysBusinessDataListComReqDto)/*vcase invoke isSameApp*/;


      queryMemorysBusinessDataListComRespDto_1 = queryMemorysBusinessDataListComRespDto;
LoopSetResourceFileComRespDto retData = new LoopSetResourceFileComRespDto();
  if(queryMemorysBusinessDataListComRespDto_1!= null&&  queryMemorysBusinessDataListComRespDto_1.getMemoryBusinessResDataList() !=null&& !CollectionUtil.isEmpty(queryMemorysBusinessDataListComRespDto_1.getMemoryBusinessResDataList())){
      retData.setResourceFileList(queryMemorysBusinessDataListComRespDto_1.getMemoryBusinessResDataList().stream().map(item->item.getCustomField1())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:2031570_1
    }




return retData;
  }
/**
   * D2执行资源文件上传第三方系统(公共)[10424]
   * gen by moon at 12/12/2024, 4:29:49 PM
   */
  @Trace(operationName = "D2执行资源文件上传第三方系统(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementResourceFileTransSystemComRespDto implementResourceFileTransSystemCom(ImplementResourceFileTransSystemComReqDto reqDto){


      ImplementResourceFileToThirdPartyRespDto thirtPartFileUploadRes_1 =null;
//步骤0: D2加载资源文件到内存(公共) - downLoadResourceFileCom
     DownLoadResourceFileComRespDto downLoadResourceFileComRespDto = null;
    DownLoadResourceFileComReqDto downLoadResourceFileComReqDto=new DownLoadResourceFileComReqDto();
  if(reqDto!=null){
      downLoadResourceFileComReqDto.setResourceFileRelaPath(reqDto.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2036659_1
    }

    /*D2加载资源文件到内存(公共)[10440]   */

      downLoadResourceFileComRespDto = downLoadResourceFileCom(downLoadResourceFileComReqDto)/*vcase invoke 同服务,同domain*/;




//步骤1: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2034959_1
queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:2036657_1
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("THIRD_QA_SYSTEM");//CUSTOM_CONVENTION//sourceId:2036656_1
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:2034961_1

    /*D2查询智能沟通配置[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D2执行资源文件上传第三方系统(公共)-D2查询智能沟通配置-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(),"D2执行资源文件上传第三方系统(公共)-D2查询智能沟通配置-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D2执行资源文件上传第三方系统(公共)-D2查询智能沟通配置-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D2执行资源文件上传第三方系统(公共)-D2查询智能沟通配置-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto)/*vcase invoke isSameApp*/;




//步骤2: M2执行三方文件上传接口（特殊方法） - implementResourceFileToThirdParty
     //ModelCode: thirtPartFileUpload
        ImplementResourceFileToThirdPartyRespDto thirtPartFileUploadRes = null;
    if(queryConfItemMatchAnswerDetailComRespDto !=null){
    ImplementResourceFileToThirdPartyReqDto thirtPartFileUploadReq=new ImplementResourceFileToThirdPartyReqDto();
  if(queryConfItemMatchAnswerDetailComRespDto!=null){
      thirtPartFileUploadReq.setIntelliQaAddress(queryConfItemMatchAnswerDetailComRespDto.getExtensionField1());//SimpleFieldAssign//sourceId:2033863_1
thirtPartFileUploadReq.setKey(queryConfItemMatchAnswerDetailComRespDto.getExtensionField2());//SimpleFieldAssign//sourceId:2033864_1
    }
  if(reqDto!=null){
thirtPartFileUploadReq.setResourceFileRelaPath(reqDto.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2033872_1
    }

    /*M2执行三方文件上传接口（特殊方法）[10421]   */
    Assert.isNull(thirtPartFileUploadReq.getIntelliQaAddress(),"D2执行资源文件上传第三方系统(公共)-M2执行三方文件上传接口（特殊方法）-第三方智能问答地址不能为空",false);
Assert.isNull(thirtPartFileUploadReq.getKey(),"D2执行资源文件上传第三方系统(公共)-M2执行三方文件上传接口（特殊方法）-key不能为空",false);
Assert.isNull(thirtPartFileUploadReq.getResourceFileRelaPath(),"D2执行资源文件上传第三方系统(公共)-M2执行三方文件上传接口（特殊方法）-资源文件相对路径不能为空",false);
      thirtPartFileUploadRes = nbResourceFile.implementResourceFileToThirdParty(thirtPartFileUploadReq);


      thirtPartFileUploadRes_1 = thirtPartFileUploadRes;
           }

ImplementResourceFileTransSystemComRespDto retData = new ImplementResourceFileTransSystemComRespDto();
  if(thirtPartFileUploadRes_1!=null){
      retData.setThirtPartFileId(thirtPartFileUploadRes_1.getThirtPartFileId());//SimpleFieldAssign//sourceId:2033868_1
    }




return retData;
  }
/**
   * D2执行资源文件上链(公共)[10431]
   * gen by moon at 12/8/2024, 11:51:48 PM
   */
  @Trace(operationName = "D2执行资源文件上链(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementEviFileChainComRespDto implementEviFileChainCom(ImplementEviFileChainComReqDto reqDto){


      ImplementEviFileChainRespDto resourceFileChainRes_1 =null;
//步骤0: M2执行资源文件上链（特殊方法) - implementEviFileChain
     //ModelCode: resourceFileChain
        ImplementEviFileChainRespDto resourceFileChainRes = null;
    ImplementEviFileChainReqDto resourceFileChainReq=new ImplementEviFileChainReqDto();
  if(reqDto!=null){
      resourceFileChainReq.setValidChainCreate(reqDto.getValidChainCreate());//SimpleFieldAssign//sourceId:2034963_1
      resourceFileChainReq.setAppKey(reqDto.getAppKey());//SimpleFieldAssign//sourceId:2034241_1
resourceFileChainReq.setChainSignature(reqDto.getChainSignature());//SimpleFieldAssign//sourceId:2034243_1
resourceFileChainReq.setChainTimeMap(reqDto.getChainTimeMap());//SimpleFieldAssign//sourceId:2034240_1
resourceFileChainReq.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:2034242_1
resourceFileChainReq.setIdentType(reqDto.getIdentType());//SimpleFieldAssign//sourceId:2034236_1
resourceFileChainReq.setIdentNo(reqDto.getIdentNo());//SimpleFieldAssign//sourceId:2034237_1
resourceFileChainReq.setProductId(reqDto.getProductId());//SimpleFieldAssign//sourceId:2034238_1
resourceFileChainReq.setWorkId(reqDto.getWorkId());//SimpleFieldAssign//sourceId:2034239_1
resourceFileChainReq.setStepId(reqDto.getStepId());//SimpleFieldAssign//sourceId:2034235_1
    }
if(reqDto!= null&&  reqDto.getItemList() !=null&& !CollectionUtil.isEmpty(reqDto.getItemList())){
      resourceFileChainReq.setItemList(reqDto.getItemList().stream().map(item -> BeanUtil.toBean(item, ItemDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2034244_1
    }

    /*M2执行资源文件上链（特殊方法)[10428]   */
    Assert.isNull(resourceFileChainReq.getAppKey(),"D2执行资源文件上链(公共)-M2执行资源文件上链（特殊方法)-上链用户Key不能为空",false);
Assert.isNull(resourceFileChainReq.getChainSignature(),"D2执行资源文件上链(公共)-M2执行资源文件上链（特殊方法)-上链签名不能为空",false);
Assert.isNull(resourceFileChainReq.getChainTimeMap(),"D2执行资源文件上链(公共)-M2执行资源文件上链（特殊方法)-上链系统时间戳不能为空",false);
Assert.isNull(resourceFileChainReq.getProductId(),"D2执行资源文件上链(公共)-M2执行资源文件上链（特殊方法)-上链业务ID不能为空",false);
Assert.isNull(resourceFileChainReq.getWorkId(),"D2执行资源文件上链(公共)-M2执行资源文件上链（特殊方法)-上链事务ID不能为空",false);
Assert.isNull(resourceFileChainReq.getStepId(),"D2执行资源文件上链(公共)-M2执行资源文件上链（特殊方法)-上链节点ID不能为空",false);
      resourceFileChainRes = nbResourceFile.implementEviFileChain(resourceFileChainReq);


      resourceFileChainRes_1 = resourceFileChainRes;

ImplementEviFileChainComRespDto retData = new ImplementEviFileChainComRespDto();
  if(resourceFileChainRes_1!=null){
      retData.setChainAddress(resourceFileChainRes_1.getChainAddress());//SimpleFieldAssign//sourceId:2034259_1
retData.setHashCal(resourceFileChainRes_1.getHashCal());//SimpleFieldAssign//sourceId:2034260_1
retData.setDataId(resourceFileChainRes_1.getDataId());//SimpleFieldAssign//sourceId:2034261_1
retData.setDataHash(resourceFileChainRes_1.getDataHash());//SimpleFieldAssign//sourceId:2034262_1
    }




return retData;
  }
/**
   * D2生成上链签名(公共)[10432]
   * gen by moon at 12/8/2024, 3:22:31 AM
   */
  @Trace(operationName = "D2生成上链签名(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ObtainChainTokenComRespDto obtainChainTokenCom(ObtainChainTokenComReqDto reqDto){


      ObtainChainTokenRespDto obtainChainTokenRes_1 =null;
//步骤0: M2生成上链签名（特殊方法) - obtainChainToken
     //ModelCode: obtainChainToken
        ObtainChainTokenRespDto obtainChainTokenRes = null;
    ObtainChainTokenReqDto obtainChainTokenReq=new ObtainChainTokenReqDto();
  obtainChainTokenReq.setChainCreateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:2034265_1
if(reqDto!=null){
      obtainChainTokenReq.setAppKey(reqDto.getAppKey());//SimpleFieldAssign//sourceId:2034263_1
obtainChainTokenReq.setAppSecret(reqDto.getAppSecret());//SimpleFieldAssign//sourceId:2034264_1
    }

    /*M2生成上链签名（特殊方法)[10430]   */
    Assert.isNull(obtainChainTokenReq.getAppKey(),"D2生成上链签名(公共)-M2生成上链签名（特殊方法)-上链用户Key不能为空",false);
Assert.isNull(obtainChainTokenReq.getAppSecret(),"D2生成上链签名(公共)-M2生成上链签名（特殊方法)-上链用户密钥不能为空",false);
Assert.isNull(obtainChainTokenReq.getChainCreateTime(),"D2生成上链签名(公共)-M2生成上链签名（特殊方法)-上链系统时间不能为空",false);
      obtainChainTokenRes = nbResourceFile.obtainChainToken(obtainChainTokenReq);


      obtainChainTokenRes_1 = obtainChainTokenRes;

ObtainChainTokenComRespDto retData = new ObtainChainTokenComRespDto();
  if(obtainChainTokenRes_1!=null){
      retData.setChainSignature(obtainChainTokenRes_1.getChainSignature());//SimpleFieldAssign//sourceId:2034271_1
retData.setChainTimeMap(obtainChainTokenRes_1.getChainTimeMap());//SimpleFieldAssign//sourceId:2034272_1
    }




return retData;
  }
/**
   * D2执行资源文件上区块链(公共)[10433]
   * gen by moon at 12/8/2024, 11:51:54 PM
   */
  @Trace(operationName = "D2执行资源文件上区块链(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementEviFilesChainComRespDto implementEviFilesChainCom(ImplementEviFilesChainComReqDto reqDto){


      ImplementEviFileChainComRespDto implementEviFileChainComRespDto_1 =null;
//步骤0: D2-3配置项匹配多选结果转答案(公共) - queryItemMatchMultiSelectResultToAnswerListCom
     QueryItemMatchMultiSelectResultToAnswerListComRespDto queryItemMatchMultiSelectResultToAnswerListComRespDto = null;
    QueryItemMatchMultiSelectResultToAnswerListComReqDto queryItemMatchMultiSelectResultToAnswerListComReqDto=new QueryItemMatchMultiSelectResultToAnswerListComReqDto();
  queryItemMatchMultiSelectResultToAnswerListComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2034344_1
queryItemMatchMultiSelectResultToAnswerListComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:2034345_1
queryItemMatchMultiSelectResultToAnswerListComReqDto.setConfItemCode("VALID_CHAIN_URL_ADDRESS");//CUSTOM_CONVENTION//sourceId:2034346_1
queryItemMatchMultiSelectResultToAnswerListComReqDto.setIsPlatData("FALSE");//sourceId:2034347_1

    /*D2查区块链地址[5196]   */
    Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto.getResultAspObjId(),"D2执行资源文件上区块链(公共)-D2查区块链地址-开通对象ID不能为空",false);
Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto.getResultAspObjType(),"D2执行资源文件上区块链(公共)-D2查区块链地址-开通对象类型编码不能为空",false);
Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto.getConfItemCode(),"D2执行资源文件上区块链(公共)-D2查区块链地址-配置项标识不能为空",false);
Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto.getIsPlatData(),"D2执行资源文件上区块链(公共)-D2查区块链地址-是否标准答案不能为空",false);
      queryItemMatchMultiSelectResultToAnswerListComRespDto = confSchemeService.queryItemMatchMultiSelectResultToAnswerListCom(queryItemMatchMultiSelectResultToAnswerListComReqDto)/*vcase invoke isSameApp*/;




//步骤1: D2-3配置项匹配多选结果转答案(公共) - queryItemMatchMultiSelectResultToAnswerListCom
     QueryItemMatchMultiSelectResultToAnswerListComRespDto queryItemMatchMultiSelectResultToAnswerListComRespDto_2 = null;
    QueryItemMatchMultiSelectResultToAnswerListComReqDto queryItemMatchMultiSelectResultToAnswerListComReqDto_1=new QueryItemMatchMultiSelectResultToAnswerListComReqDto();
  queryItemMatchMultiSelectResultToAnswerListComReqDto_1.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2034383_1
queryItemMatchMultiSelectResultToAnswerListComReqDto_1.setResultAspObjType("TENANT_SPACE");//sourceId:2034384_1
queryItemMatchMultiSelectResultToAnswerListComReqDto_1.setConfItemCode("VALID_CHAIN_USER_INFO");//CUSTOM_CONVENTION//sourceId:2034385_1
queryItemMatchMultiSelectResultToAnswerListComReqDto_1.setIsPlatData("FALSE");//sourceId:2034386_1

    /*D2查区块链用户信息[5196]   */
    Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_1.getResultAspObjId(),"D2执行资源文件上区块链(公共)-D2查区块链用户信息-开通对象ID不能为空",false);
Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_1.getResultAspObjType(),"D2执行资源文件上区块链(公共)-D2查区块链用户信息-开通对象类型编码不能为空",false);
Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_1.getConfItemCode(),"D2执行资源文件上区块链(公共)-D2查区块链用户信息-配置项标识不能为空",false);
Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_1.getIsPlatData(),"D2执行资源文件上区块链(公共)-D2查区块链用户信息-是否标准答案不能为空",false);
      queryItemMatchMultiSelectResultToAnswerListComRespDto_2 = confSchemeService.queryItemMatchMultiSelectResultToAnswerListCom(queryItemMatchMultiSelectResultToAnswerListComReqDto_1)/*vcase invoke isSameApp*/;




//步骤2: D2-3配置项匹配多选结果转答案(公共) - queryItemMatchMultiSelectResultToAnswerListCom
     QueryItemMatchMultiSelectResultToAnswerListComRespDto queryItemMatchMultiSelectResultToAnswerListComRespDto_4 = null;
    QueryItemMatchMultiSelectResultToAnswerListComReqDto queryItemMatchMultiSelectResultToAnswerListComReqDto_2=new QueryItemMatchMultiSelectResultToAnswerListComReqDto();
  queryItemMatchMultiSelectResultToAnswerListComReqDto_2.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2034422_1
queryItemMatchMultiSelectResultToAnswerListComReqDto_2.setResultAspObjType("TENANT_SPACE");//sourceId:2034423_1
queryItemMatchMultiSelectResultToAnswerListComReqDto_2.setConfItemCode("VALID_CHAIN_INFO");//CUSTOM_CONVENTION//sourceId:2034424_1
queryItemMatchMultiSelectResultToAnswerListComReqDto_2.setIsPlatData("FALSE");//sourceId:2034425_1

    /*D2查区块链上链信息[5196]   */
    Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_2.getResultAspObjId(),"D2执行资源文件上区块链(公共)-D2查区块链上链信息-开通对象ID不能为空",false);
Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_2.getResultAspObjType(),"D2执行资源文件上区块链(公共)-D2查区块链上链信息-开通对象类型编码不能为空",false);
Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_2.getConfItemCode(),"D2执行资源文件上区块链(公共)-D2查区块链上链信息-配置项标识不能为空",false);
Assert.isNull(queryItemMatchMultiSelectResultToAnswerListComReqDto_2.getIsPlatData(),"D2执行资源文件上区块链(公共)-D2查区块链上链信息-是否标准答案不能为空",false);
      queryItemMatchMultiSelectResultToAnswerListComRespDto_4 = confSchemeService.queryItemMatchMultiSelectResultToAnswerListCom(queryItemMatchMultiSelectResultToAnswerListComReqDto_2)/*vcase invoke isSameApp*/;




//步骤3: D2生成上链签名(公共) - obtainChainTokenCom
     ObtainChainTokenComRespDto obtainChainTokenComRespDto = null;
    if(queryItemMatchMultiSelectResultToAnswerListComRespDto_2 !=null){
          ObtainChainTokenComReqDto obtainChainTokenComReqDto=new ObtainChainTokenComReqDto();
  if(queryItemMatchMultiSelectResultToAnswerListComRespDto_2!=null){
      obtainChainTokenComReqDto.setAppKey(queryItemMatchMultiSelectResultToAnswerListComRespDto_2.getAppKey());//SimpleFieldAssign//sourceId:2034308_1
obtainChainTokenComReqDto.setAppSecret(queryItemMatchMultiSelectResultToAnswerListComRespDto_2.getAppSecret());//SimpleFieldAssign//sourceId:2034309_1
    }

    /*D2生成上链签名(公共)[10432]   */
    Assert.isNull(obtainChainTokenComReqDto.getAppKey(),"D2执行资源文件上区块链(公共)-D2生成上链签名(公共)-上链用户Key不能为空",false);
Assert.isNull(obtainChainTokenComReqDto.getAppSecret(),"D2执行资源文件上区块链(公共)-D2生成上链签名(公共)-上链用户密钥不能为空",false);
      obtainChainTokenComRespDto = obtainChainTokenCom(obtainChainTokenComReqDto)/*vcase invoke 同服务,同domain*/;



           }

//步骤4: D2执行资源文件上链(公共) - implementEviFileChainCom
     ImplementEviFileChainComRespDto implementEviFileChainComRespDto = null;
    if(queryItemMatchMultiSelectResultToAnswerListComRespDto !=null){
          ImplementEviFileChainComReqDto implementEviFileChainComReqDto=new ImplementEviFileChainComReqDto();
  if(queryItemMatchMultiSelectResultToAnswerListComRespDto!=null){
      implementEviFileChainComReqDto.setValidChainCreate(queryItemMatchMultiSelectResultToAnswerListComRespDto.getValidChainCreate());//SimpleFieldAssign//sourceId:2034965_1
    }
  if(queryItemMatchMultiSelectResultToAnswerListComRespDto_2!=null){
      implementEviFileChainComReqDto.setAppKey(queryItemMatchMultiSelectResultToAnswerListComRespDto_2.getAppKey());//SimpleFieldAssign//sourceId:2034294_1
    }
if(obtainChainTokenComRespDto!=null){
      implementEviFileChainComReqDto.setChainSignature(obtainChainTokenComRespDto.getChainSignature());//SimpleFieldAssign//sourceId:2034295_1
implementEviFileChainComReqDto.setChainTimeMap(obtainChainTokenComRespDto.getChainTimeMap());//SimpleFieldAssign//sourceId:2034296_1
    }
if(reqDto!= null&&  reqDto.getItemList() !=null&& !CollectionUtil.isEmpty(reqDto.getItemList())){
      implementEviFileChainComReqDto.setItemList(reqDto.getItemList().stream().map(item -> BeanUtil.toBean(item, ItemDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2034303_1
    }
if(reqDto!=null){
implementEviFileChainComReqDto.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:2034297_1
implementEviFileChainComReqDto.setIdentType(reqDto.getIdentType());//SimpleFieldAssign//sourceId:2034298_1
implementEviFileChainComReqDto.setIdentNo(reqDto.getIdentNo());//SimpleFieldAssign//sourceId:2034299_1
    }
if(queryItemMatchMultiSelectResultToAnswerListComRespDto_4!=null){
      implementEviFileChainComReqDto.setProductId(queryItemMatchMultiSelectResultToAnswerListComRespDto_4.getProductId());//SimpleFieldAssign//sourceId:2034300_1
implementEviFileChainComReqDto.setStepId(queryItemMatchMultiSelectResultToAnswerListComRespDto_4.getStepId());//SimpleFieldAssign//sourceId:2034302_1
implementEviFileChainComReqDto.setWorkId(queryItemMatchMultiSelectResultToAnswerListComRespDto_4.getWorkId());//SimpleFieldAssign//sourceId:2034301_1
    }

    /*D2执行资源文件上链(公共)[10431]   */
    Assert.isNull(implementEviFileChainComReqDto.getAppKey(),"D2执行资源文件上区块链(公共)-D2执行资源文件上链(公共)-上链用户Key不能为空",false);
Assert.isNull(implementEviFileChainComReqDto.getChainSignature(),"D2执行资源文件上区块链(公共)-D2执行资源文件上链(公共)-上链签名不能为空",false);
Assert.isNull(implementEviFileChainComReqDto.getChainTimeMap(),"D2执行资源文件上区块链(公共)-D2执行资源文件上链(公共)-上链系统时间戳不能为空",false);
Assert.isNull(implementEviFileChainComReqDto.getProductId(),"D2执行资源文件上区块链(公共)-D2执行资源文件上链(公共)-上链业务ID不能为空",false);
Assert.isNull(implementEviFileChainComReqDto.getStepId(),"D2执行资源文件上区块链(公共)-D2执行资源文件上链(公共)-上链节点ID不能为空",false);
Assert.isNull(implementEviFileChainComReqDto.getWorkId(),"D2执行资源文件上区块链(公共)-D2执行资源文件上链(公共)-上链事务ID不能为空",false);
      implementEviFileChainComRespDto = implementEviFileChainCom(implementEviFileChainComReqDto)/*vcase invoke 同服务,同domain*/;


      implementEviFileChainComRespDto_1 = implementEviFileChainComRespDto;
           }

ImplementEviFilesChainComRespDto retData = new ImplementEviFilesChainComRespDto();
  if(implementEviFileChainComRespDto_1!=null){
      retData.setChainAddress(implementEviFileChainComRespDto_1.getChainAddress());//SimpleFieldAssign//sourceId:2034966_1
retData.setHashCal(implementEviFileChainComRespDto_1.getHashCal());//SimpleFieldAssign//sourceId:2034967_1
      retData.setDataId(implementEviFileChainComRespDto_1.getDataId());//SimpleFieldAssign//sourceId:2034788_1
retData.setDataHash(implementEviFileChainComRespDto_1.getDataHash());//SimpleFieldAssign//sourceId:2034789_1
    }




return retData;
  }
/**
   * D2生成资源文件问答内容(公共)[10426]
   * gen by moon at 12/12/2024, 4:29:48 PM
   */
  @Trace(operationName = "D2生成资源文件问答内容(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public GenerateResourceFileQuestionContentComRespDto generateResourceFileQuestionContentCom(GenerateResourceFileQuestionContentComReqDto reqDto){


      AddObjectStorageConfigRespDto receptionServiceRes_1 =null;
GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto_6 =null;
if((reqDto!= null&&  reqDto.getFileQaModel() !=null && reqDto.getFileQaModel().equals("SINGLE_LONG_TEXT_Q_MODEL"))) {
        //if(D2生成资源文件问答内容(公共).文件问答模式 等于 单个长文本提问模式)  73702

GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto = null;
    GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto=new GenerateSemanticInstanceStoryComReqDto();
  generateSemanticInstanceStoryComReqDto.setTemplateSemanticEngineCode("SINGLE_LONG_TEXT_QUESTION");//CUSTOM_CONVENTION//sourceId:2034150_1_73705
generateSemanticInstanceStoryComReqDto.setFirstFieldName("thirtPartFileId");//CUSTOM_CONVENTION//sourceId:2034151_1_73705
if(reqDto!=null){
      generateSemanticInstanceStoryComReqDto.setFirstFieldValue(reqDto.getThirtPartFileId());//SimpleFieldAssign//sourceId:2034152_1_73705
    }

    /*D2生成单个长文本提问命令[8234]   */
    Assert.isNull(generateSemanticInstanceStoryComReqDto.getTemplateSemanticEngineCode(),"D2生成资源文件问答内容(公共)-D2生成单个长文本提问命令-模板引擎标识不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldName(),"D2生成资源文件问答内容(公共)-D2生成单个长文本提问命令-第一个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldValue(),"D2生成资源文件问答内容(公共)-D2生成单个长文本提问命令-第一个字段字段值不能为空",false);
      generateSemanticInstanceStoryComRespDto = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto)/*vcase invoke isSameApp*/;



//ModelCode: receptionService
        AddObjectStorageConfigRespDto receptionServiceRes = null;
    if(generateSemanticInstanceStoryComRespDto !=null){
          AddObjectStorageConfigReqDto receptionServiceReq=new AddObjectStorageConfigReqDto();
  if(generateSemanticInstanceStoryComRespDto!=null){
      receptionServiceReq.setCustomField(generateSemanticInstanceStoryComRespDto.getObjectName());//SimpleFieldAssign//sourceId:2035000_1_73710
    }

    /*接收问答命令出参[10411]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField(),"D2生成资源文件问答内容(公共)-接收问答命令出参-自定义字段不能为空",false);
      receptionServiceRes = nbResourceFile.addObjectStorageConfig(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((reqDto!= null&&  reqDto.getFileQaModel() !=null && reqDto.getFileQaModel().equals("SINGLE_LONG_TEXT_AQ_MODEL"))){
       //elseif(D2生成资源文件问答内容(公共).文件问答模式 等于 单个长文本追问模式)  73703

GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto_2 = null;
    GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto_1=new GenerateSemanticInstanceStoryComReqDto();


    /*D2生成多个长文本提问命令[8234]   */
    Assert.isNull(generateSemanticInstanceStoryComReqDto_1.getTemplateSemanticEngineCode(),"D2生成资源文件问答内容(公共)-D2生成多个长文本提问命令-模板引擎标识不能为空",false);
      generateSemanticInstanceStoryComRespDto_2 = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto_1)/*vcase invoke isSameApp*/;



//ModelCode: receptionService
        AddObjectStorageConfigRespDto receptionServiceRes_2 = null;
    if(generateSemanticInstanceStoryComRespDto_2 !=null){
          AddObjectStorageConfigReqDto receptionServiceReq_1=new AddObjectStorageConfigReqDto();
  if(generateSemanticInstanceStoryComRespDto_2!=null){
      receptionServiceReq_1.setCustomField(generateSemanticInstanceStoryComRespDto_2.getObjectName());//SimpleFieldAssign//sourceId:2035000_1_73711
    }

    /*接收问答命令出参[10411]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getCustomField(),"D2生成资源文件问答内容(公共)-接收问答命令出参-自定义字段不能为空",false);
      receptionServiceRes_2 = nbResourceFile.addObjectStorageConfig(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
else if((reqDto!= null&&  reqDto.getFileQaModel() !=null && reqDto.getFileQaModel().equals("MUTI_LONG_TEXT_Q_MODEL"))){
       //elseif(D2生成资源文件问答内容(公共).文件问答模式 等于 多个文本提问模式)  73704

GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto_4 = null;
    GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto_2=new GenerateSemanticInstanceStoryComReqDto();


    /*D2生成多个长文本提问命令[8234]   */
    Assert.isNull(generateSemanticInstanceStoryComReqDto_2.getTemplateSemanticEngineCode(),"D2生成资源文件问答内容(公共)-D2生成多个长文本提问命令-模板引擎标识不能为空",false);
      generateSemanticInstanceStoryComRespDto_4 = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto_2)/*vcase invoke isSameApp*/;



//ModelCode: receptionService
        AddObjectStorageConfigRespDto receptionServiceRes_3 = null;
    if(generateSemanticInstanceStoryComRespDto_4 !=null){
          AddObjectStorageConfigReqDto receptionServiceReq_2=new AddObjectStorageConfigReqDto();
  if(generateSemanticInstanceStoryComRespDto_4!=null){
      receptionServiceReq_2.setCustomField(generateSemanticInstanceStoryComRespDto_4.getObjectName());//SimpleFieldAssign//sourceId:2035000_1_73712
    }

    /*接收问答命令出参[10411]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getCustomField(),"D2生成资源文件问答内容(公共)-接收问答命令出参-自定义字段不能为空",false);
      receptionServiceRes_3 = nbResourceFile.addObjectStorageConfig(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
           }
    }
//virtualUsage D2生成文件问答询问内容  73720
      GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto_5 = null;
    GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto_3=new GenerateSemanticInstanceStoryComReqDto();


    /*D2生成文件问答询问内容[8234]   */
    Assert.isNull(generateSemanticInstanceStoryComReqDto_3.getTemplateSemanticEngineCode(),"D2生成资源文件问答内容(公共)-D2生成文件问答询问内容-模板引擎标识不能为空",false);
      generateSemanticInstanceStoryComRespDto_5 = templateEngineService.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto_3)/*vcase invoke isSameApp*/;


      generateSemanticInstanceStoryComRespDto_6 = generateSemanticInstanceStoryComRespDto_5;
GenerateResourceFileQuestionContentComRespDto retData = new GenerateResourceFileQuestionContentComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setCustomField(receptionServiceRes_1.getCustomField());//SimpleFieldAssign//sourceId:2035317_1
    }
if(generateSemanticInstanceStoryComRespDto_6!=null){
      retData.setObjectName(generateSemanticInstanceStoryComRespDto_6.getObjectName());//SimpleFieldAssign//sourceId:2035648_1
    }




return retData;
  }
/**
   * D2加载资源文件到内存(公共)[10440]
   * gen by moon at 12/15/2024, 5:26:53 PM
   */
  @Trace(operationName = "D2加载资源文件到内存(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public DownLoadResourceFileComRespDto downLoadResourceFileCom(DownLoadResourceFileComReqDto reqDto){


      //virtualUsage D2查询上传配置信息详情(公共)  73713
      QueryUploadConfigInfoDetailComRespDto queryUploadConfigInfoDetailComRespDto = null;
    QueryUploadConfigInfoDetailComReqDto queryUploadConfigInfoDetailComReqDto=new QueryUploadConfigInfoDetailComReqDto();


    /*D2查询上传配置信息详情(公共)[10408]   */

      queryUploadConfigInfoDetailComRespDto = netDiskService.queryUploadConfigInfoDetailCom(queryUploadConfigInfoDetailComReqDto)/*vcase invoke isSameApp*/;



if((queryUploadConfigInfoDetailComRespDto!= null&& queryUploadConfigInfoDetailComRespDto.getAliyunOssServiceAddress() != null )) {
        //if(D2查询上传配置信息详情(公共).阿里云OSS服务地址 值不等于空 )  73714

LoadAliYunFileComRespDto loadAliYunFileComRespDto = null;
    if(queryUploadConfigInfoDetailComRespDto !=null){
          LoadAliYunFileComReqDto loadAliYunFileComReqDto=new LoadAliYunFileComReqDto();
  if(queryUploadConfigInfoDetailComRespDto!=null){
      loadAliYunFileComReqDto.setAliyunOssServiceAddress(queryUploadConfigInfoDetailComRespDto.getAliyunOssDisplayRootPath());//SimpleFieldAssign//sourceId:2035062_1_73717
loadAliYunFileComReqDto.setAliyunOssKey(queryUploadConfigInfoDetailComRespDto.getAliyunOssKey());//SimpleFieldAssign//sourceId:2035063_1_73717
loadAliYunFileComReqDto.setAliyunOssSecretKey(queryUploadConfigInfoDetailComRespDto.getAliyunOssSecretKey());//SimpleFieldAssign//sourceId:2035064_1_73717
loadAliYunFileComReqDto.setAliyunOssBucketName(queryUploadConfigInfoDetailComRespDto.getAliyunOssBucketName());//SimpleFieldAssign//sourceId:2035065_1_73717
    }
if(reqDto!=null){
      loadAliYunFileComReqDto.setFile(reqDto.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2035066_1_73717
    }

    /*D2获取阿里云文件(公共)[10445]   */
    Assert.isNull(loadAliYunFileComReqDto.getAliyunOssServiceAddress(),"D2加载资源文件到内存(公共)-D2获取阿里云文件(公共)-阿里云OSS服务地址不能为空",false);
Assert.isNull(loadAliYunFileComReqDto.getAliyunOssKey(),"D2加载资源文件到内存(公共)-D2获取阿里云文件(公共)-阿里云OSS的钥匙不能为空",false);
Assert.isNull(loadAliYunFileComReqDto.getAliyunOssSecretKey(),"D2加载资源文件到内存(公共)-D2获取阿里云文件(公共)-阿里云OSS的密钥不能为空",false);
Assert.isNull(loadAliYunFileComReqDto.getAliyunOssBucketName(),"D2加载资源文件到内存(公共)-D2获取阿里云文件(公共)-阿里云OSS桶名字不能为空",false);
Assert.isNull(loadAliYunFileComReqDto.getFile(),"D2加载资源文件到内存(公共)-D2获取阿里云文件(公共)-文件不能为空",false);
      loadAliYunFileComRespDto = loadAliYunFileCom(loadAliYunFileComReqDto)/*vcase invoke 同服务,同domain*/;



           }
      }
else if((queryUploadConfigInfoDetailComRespDto!= null&& queryUploadConfigInfoDetailComRespDto.getMinioServiceAddress() != null )){
       //elseif(D2查询上传配置信息详情(公共).MINIO服务地址 值不等于空 )  73715

LoadMinioFileComRespDto loadMinioFileComRespDto = null;
    if(queryUploadConfigInfoDetailComRespDto !=null){
          LoadMinioFileComReqDto loadMinioFileComReqDto=new LoadMinioFileComReqDto();
  if(queryUploadConfigInfoDetailComRespDto!=null){
      loadMinioFileComReqDto.setMinioServiceAddress(queryUploadConfigInfoDetailComRespDto.getMinioServiceAddress());//SimpleFieldAssign//sourceId:2035067_1_73718
loadMinioFileComReqDto.setMinioKey(queryUploadConfigInfoDetailComRespDto.getMinioKey());//SimpleFieldAssign//sourceId:2035068_1_73718
loadMinioFileComReqDto.setMinioSecretKey(queryUploadConfigInfoDetailComRespDto.getMinioSecretKey());//SimpleFieldAssign//sourceId:2035069_1_73718
loadMinioFileComReqDto.setMinioBucketName(queryUploadConfigInfoDetailComRespDto.getMinioBucketName());//SimpleFieldAssign//sourceId:2035070_1_73718
    }
if(reqDto!=null){
      loadMinioFileComReqDto.setFile(reqDto.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2035071_1_73718
    }

    /*D2获取minio文件(公共)[10446]   */
    Assert.isNull(loadMinioFileComReqDto.getMinioServiceAddress(),"D2加载资源文件到内存(公共)-D2获取minio文件(公共)-MINIO服务地址不能为空",false);
Assert.isNull(loadMinioFileComReqDto.getMinioKey(),"D2加载资源文件到内存(公共)-D2获取minio文件(公共)-MINIO的钥匙不能为空",false);
Assert.isNull(loadMinioFileComReqDto.getMinioSecretKey(),"D2加载资源文件到内存(公共)-D2获取minio文件(公共)-MINIO的密钥不能为空",false);
Assert.isNull(loadMinioFileComReqDto.getMinioBucketName(),"D2加载资源文件到内存(公共)-D2获取minio文件(公共)-MINIO桶名字不能为空",false);
Assert.isNull(loadMinioFileComReqDto.getFile(),"D2加载资源文件到内存(公共)-D2获取minio文件(公共)-文件不能为空",false);
      loadMinioFileComRespDto = loadMinioFileCom(loadMinioFileComReqDto)/*vcase invoke 同服务,同domain*/;



           }
    }
else if((queryUploadConfigInfoDetailComRespDto!= null&& queryUploadConfigInfoDetailComRespDto.getLocalStorageRootPath() != null )){
       //elseif(D2查询上传配置信息详情(公共).本地存储根路径 值不等于空 )  73716

LoadLocalFileComRespDto loadLocalFileComRespDto = null;
    if(queryUploadConfigInfoDetailComRespDto !=null){
    LoadLocalFileComReqDto loadLocalFileComReqDto=new LoadLocalFileComReqDto();
  if(queryUploadConfigInfoDetailComRespDto!=null){
      loadLocalFileComReqDto.setLocalStorageRootPath(queryUploadConfigInfoDetailComRespDto.getLocalStorageRootPath());//SimpleFieldAssign//sourceId:2037010_1_73719
    }
  if(reqDto!=null){
      loadLocalFileComReqDto.setFile(reqDto.getResourceFileRelaPath());//SimpleFieldAssign//sourceId:2035072_1_73719
    }

    /*D2获取本地文件(公共)[10447]   */
    Assert.isNull(loadLocalFileComReqDto.getLocalStorageRootPath(),"D2加载资源文件到内存(公共)-D2获取本地文件(公共)-本地存储根路径不能为空",false);
    Assert.isNull(loadLocalFileComReqDto.getFile(),"D2加载资源文件到内存(公共)-D2获取本地文件(公共)-文件不能为空",false);
      loadLocalFileComRespDto = loadLocalFileCom(loadLocalFileComReqDto)/*vcase invoke 同服务,同domain*/;



           }
    }
DownLoadResourceFileComRespDto retData = new DownLoadResourceFileComRespDto();





return retData;
  }
/**
   * D2组装资源文件提问列表[10441]
   * gen by moon at 12/11/2024, 11:56:43 AM
   */
  @Trace(operationName = "D2组装资源文件提问列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AssembleFileQListComRespDto assembleFileQListCom(AssembleFileQListComReqDto reqDto){


      QueryMemorysBusinessDataListComRespDto queryMemorysBusinessDataListComRespDto_1 =null;
//步骤0: M2执行智能沟通接收入参 - implementSmartSessionReceiveFieldInput
     //ModelCode: receptionService
        ImplementSmartSessionReceiveFieldInputRespDto receptionServiceRes = null;
    ImplementSmartSessionReceiveFieldInputReqDto receptionServiceReq=new ImplementSmartSessionReceiveFieldInputReqDto();
  if(reqDto!=null){
      receptionServiceReq.setContent(reqDto.getContent());//SimpleFieldAssign//sourceId:2035620_1
receptionServiceReq.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:2035649_1
    }

    /*M2执行智能沟通接收入参[8109]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getContent(),"D2组装资源文件提问列表-M2执行智能沟通接收入参-消息内容不能为空",false);
      receptionServiceRes = nbResourceFile.implementSmartSessionReceiveFieldInput(receptionServiceReq);




//步骤1: D2构造智能问答列表单条内容(公共) - addGuidedThirdPartyIntelligentQaCom
     AddGuidedThirdPartyIntelligentQaComRespDto addGuidedThirdPartyIntelligentQaComRespDto = null;
    AddGuidedThirdPartyIntelligentQaComReqDto addGuidedThirdPartyIntelligentQaComReqDto=new AddGuidedThirdPartyIntelligentQaComReqDto();
  addGuidedThirdPartyIntelligentQaComReqDto.setCustomFieldValue1("user");//CUSTOM_CONVENTION//sourceId:2035624_1
  if(reqDto!=null){
      addGuidedThirdPartyIntelligentQaComReqDto.setBusinessDataObject(reqDto.getContent());//SimpleFieldAssign//sourceId:2035623_1
addGuidedThirdPartyIntelligentQaComReqDto.setCustomFieldValue2(reqDto.getContent());//SimpleFieldAssign//sourceId:2035625_1
    }

    /*D2构造智能问答列表单条内容(公共)[10448]   */
    Assert.isNull(addGuidedThirdPartyIntelligentQaComReqDto.getBusinessDataObject(),"D2组装资源文件提问列表-D2构造智能问答列表单条内容(公共)-业务数据对象不能为空",false);
Assert.isNull(addGuidedThirdPartyIntelligentQaComReqDto.getCustomFieldValue1(),"D2组装资源文件提问列表-D2构造智能问答列表单条内容(公共)-自定义字段值1不能为空",false);
Assert.isNull(addGuidedThirdPartyIntelligentQaComReqDto.getCustomFieldValue2(),"D2组装资源文件提问列表-D2构造智能问答列表单条内容(公共)-自定义字段值2不能为空",false);
      addGuidedThirdPartyIntelligentQaComRespDto = intelligentCommunicationService.addGuidedThirdPartyIntelligentQaCom(addGuidedThirdPartyIntelligentQaComReqDto)/*vcase invoke isSameApp*/;




//步骤2: D2构造智能问答列表单条内容(公共) - addGuidedThirdPartyIntelligentQaCom
     AddGuidedThirdPartyIntelligentQaComRespDto addGuidedThirdPartyIntelligentQaComRespDto_1 = null;
    AddGuidedThirdPartyIntelligentQaComReqDto addGuidedThirdPartyIntelligentQaComReqDto_1=new AddGuidedThirdPartyIntelligentQaComReqDto();
  addGuidedThirdPartyIntelligentQaComReqDto_1.setCustomFieldValue1("system");//CUSTOM_CONVENTION//sourceId:2035627_1
  if(reqDto!=null){
      addGuidedThirdPartyIntelligentQaComReqDto_1.setBusinessDataObject(reqDto.getContent());//SimpleFieldAssign//sourceId:2035626_1
addGuidedThirdPartyIntelligentQaComReqDto_1.setCustomFieldValue2(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:2035628_1
    }

    /*D2构造智能问答列表单条内容(公共)[10448]   */
    Assert.isNull(addGuidedThirdPartyIntelligentQaComReqDto_1.getBusinessDataObject(),"D2组装资源文件提问列表-D2构造智能问答列表单条内容(公共)-业务数据对象不能为空",false);
Assert.isNull(addGuidedThirdPartyIntelligentQaComReqDto_1.getCustomFieldValue1(),"D2组装资源文件提问列表-D2构造智能问答列表单条内容(公共)-自定义字段值1不能为空",false);
Assert.isNull(addGuidedThirdPartyIntelligentQaComReqDto_1.getCustomFieldValue2(),"D2组装资源文件提问列表-D2构造智能问答列表单条内容(公共)-自定义字段值2不能为空",false);
      addGuidedThirdPartyIntelligentQaComRespDto_1 = intelligentCommunicationService.addGuidedThirdPartyIntelligentQaCom(addGuidedThirdPartyIntelligentQaComReqDto_1)/*vcase invoke isSameApp*/;




//步骤3: D2查询内存业务数据列表(业务原子) - queryMemorysBusinessDataListCom
     QueryMemorysBusinessDataListComRespDto queryMemorysBusinessDataListComRespDto = null;
    QueryMemorysBusinessDataListComReqDto queryMemorysBusinessDataListComReqDto=new QueryMemorysBusinessDataListComReqDto();
  queryMemorysBusinessDataListComReqDto.setDataObjectBatchCode(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:2035654_1
queryMemorysBusinessDataListComReqDto.setCustomField1("role");//CUSTOM_CONVENTION//sourceId:2035653_1
queryMemorysBusinessDataListComReqDto.setCustomField2("content");//CUSTOM_CONVENTION//sourceId:2035655_1
if(reqDto!=null){
      queryMemorysBusinessDataListComReqDto.setBusinessDataObject(reqDto.getContent());//SimpleFieldAssign//sourceId:2035652_1
    }

    /*D2获取消息问答列表[10425]   */
    Assert.isNull(queryMemorysBusinessDataListComReqDto.getBusinessDataObject(),"D2组装资源文件提问列表-D2获取消息问答列表-业务数据对象不能为空",false);
Assert.isNull(queryMemorysBusinessDataListComReqDto.getDataObjectBatchCode(),"D2组装资源文件提问列表-D2获取消息问答列表-数据对象批次标识不能为空",false);
Assert.isNull(queryMemorysBusinessDataListComReqDto.getCustomField1(),"D2组装资源文件提问列表-D2获取消息问答列表-自定义字段1不能为空",false);
Assert.isNull(queryMemorysBusinessDataListComReqDto.getCustomField2(),"D2组装资源文件提问列表-D2获取消息问答列表-自定义字段2不能为空",false);
      queryMemorysBusinessDataListComRespDto = interfaceModeService.queryMemorysBusinessDataListCom(queryMemorysBusinessDataListComReqDto)/*vcase invoke isSameApp*/;


      queryMemorysBusinessDataListComRespDto_1 = queryMemorysBusinessDataListComRespDto;

AssembleFileQListComRespDto retData = new AssembleFileQListComRespDto();
  if(queryMemorysBusinessDataListComRespDto_1!=null){
      retData.setOutputBusinessDataList(queryMemorysBusinessDataListComRespDto_1.getMemoryBusinessResDataList().stream().map(item -> BeanUtil.toBean(item, OutputBusinessDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:2035663_1
    }




return retData;
  }
/**
   * D2获取阿里云文件(公共)[10445]
   * gen by moon at 12/10/2024, 12:01:08 AM
   */
  @Trace(operationName = "D2获取阿里云文件(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public LoadAliYunFileComRespDto loadAliYunFileCom(LoadAliYunFileComReqDto reqDto){


      //步骤0: M2从阿里云加载文件到内存（特殊方法） - loadFileFromAliYun
     //ModelCode: loadFileToMemory
        LoadFileFromAliYunRespDto loadFileToMemoryRes = null;
    LoadFileFromAliYunReqDto loadFileToMemoryReq=new LoadFileFromAliYunReqDto();
  if(reqDto!=null){
      loadFileToMemoryReq.setAliyunOssServiceAddress(reqDto.getAliyunOssServiceAddress());//SimpleFieldAssign//sourceId:2035013_1
loadFileToMemoryReq.setAliyunOssKey(reqDto.getAliyunOssKey());//SimpleFieldAssign//sourceId:2035014_1
loadFileToMemoryReq.setAliyunOssSecretKey(reqDto.getAliyunOssSecretKey());//SimpleFieldAssign//sourceId:2035015_1
loadFileToMemoryReq.setAliyunOssBucketName(reqDto.getAliyunOssBucketName());//SimpleFieldAssign//sourceId:2035016_1
loadFileToMemoryReq.setFile(reqDto.getFile());//SimpleFieldAssign//sourceId:2035017_1
    }

    /*M2从阿里云加载文件到内存（特殊方法）[10442]   */
    Assert.isNull(loadFileToMemoryReq.getAliyunOssServiceAddress(),"D2获取阿里云文件(公共)-M2从阿里云加载文件到内存（特殊方法）-阿里云OSS服务地址不能为空",false);
Assert.isNull(loadFileToMemoryReq.getAliyunOssKey(),"D2获取阿里云文件(公共)-M2从阿里云加载文件到内存（特殊方法）-阿里云OSS的钥匙不能为空",false);
Assert.isNull(loadFileToMemoryReq.getAliyunOssSecretKey(),"D2获取阿里云文件(公共)-M2从阿里云加载文件到内存（特殊方法）-阿里云OSS的密钥不能为空",false);
Assert.isNull(loadFileToMemoryReq.getAliyunOssBucketName(),"D2获取阿里云文件(公共)-M2从阿里云加载文件到内存（特殊方法）-阿里云OSS桶名字不能为空",false);
Assert.isNull(loadFileToMemoryReq.getFile(),"D2获取阿里云文件(公共)-M2从阿里云加载文件到内存（特殊方法）-文件不能为空",false);
      loadFileToMemoryRes = nbResourceFile.loadFileFromAliYun(loadFileToMemoryReq);




LoadAliYunFileComRespDto retData = new LoadAliYunFileComRespDto();





return retData;
  }
/**
   * D2获取minio文件(公共)[10446]
   * gen by moon at 12/10/2024, 12:01:25 AM
   */
  @Trace(operationName = "D2获取minio文件(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public LoadMinioFileComRespDto loadMinioFileCom(LoadMinioFileComReqDto reqDto){


      //步骤0: M2从minio加载文件到内存（特殊方法） - loadFileFromMinio
     //ModelCode: loadFileToMemory
        LoadFileFromMinioRespDto loadFileToMemoryRes = null;
    LoadFileFromMinioReqDto loadFileToMemoryReq=new LoadFileFromMinioReqDto();
  if(reqDto!=null){
      loadFileToMemoryReq.setMinioServiceAddress(reqDto.getMinioServiceAddress());//SimpleFieldAssign//sourceId:2035023_1
loadFileToMemoryReq.setMinioKey(reqDto.getMinioKey());//SimpleFieldAssign//sourceId:2035024_1
loadFileToMemoryReq.setMinioSecretKey(reqDto.getMinioSecretKey());//SimpleFieldAssign//sourceId:2035025_1
loadFileToMemoryReq.setMinioBucketName(reqDto.getMinioBucketName());//SimpleFieldAssign//sourceId:2035026_1
loadFileToMemoryReq.setFile(reqDto.getFile());//SimpleFieldAssign//sourceId:2035027_1
    }

    /*M2从minio加载文件到内存（特殊方法）[10443]   */
    Assert.isNull(loadFileToMemoryReq.getMinioServiceAddress(),"D2获取minio文件(公共)-M2从minio加载文件到内存（特殊方法）-MINIO服务地址不能为空",false);
Assert.isNull(loadFileToMemoryReq.getMinioKey(),"D2获取minio文件(公共)-M2从minio加载文件到内存（特殊方法）-MINIO的钥匙不能为空",false);
Assert.isNull(loadFileToMemoryReq.getMinioSecretKey(),"D2获取minio文件(公共)-M2从minio加载文件到内存（特殊方法）-MINIO的密钥不能为空",false);
Assert.isNull(loadFileToMemoryReq.getMinioBucketName(),"D2获取minio文件(公共)-M2从minio加载文件到内存（特殊方法）-MINIO桶名字不能为空",false);
Assert.isNull(loadFileToMemoryReq.getFile(),"D2获取minio文件(公共)-M2从minio加载文件到内存（特殊方法）-文件不能为空",false);
      loadFileToMemoryRes = nbResourceFile.loadFileFromMinio(loadFileToMemoryReq);




LoadMinioFileComRespDto retData = new LoadMinioFileComRespDto();





return retData;
  }
/**
   * D2获取本地文件(公共)[10447]
   * gen by moon at 12/15/2024, 4:49:45 PM
   */
  @Trace(operationName = "D2获取本地文件(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public LoadLocalFileComRespDto loadLocalFileCom(LoadLocalFileComReqDto reqDto){


      //步骤0: M2从本地加载文件到内存（特殊方法） - loadFileFromLocal
     //ModelCode: loadFileToMemory
        LoadFileFromLocalRespDto loadFileToMemoryRes = null;
    LoadFileFromLocalReqDto loadFileToMemoryReq=new LoadFileFromLocalReqDto();
  if(reqDto!=null){
      loadFileToMemoryReq.setFile(reqDto.getFile());//SimpleFieldAssign//sourceId:2035033_1
loadFileToMemoryReq.setLocalStorageRootPath(reqDto.getLocalStorageRootPath());//SimpleFieldAssign//sourceId:2037008_1
    }

    /*M2从本地加载文件到内存（特殊方法）[10444]   */
    Assert.isNull(loadFileToMemoryReq.getFile(),"D2获取本地文件(公共)-M2从本地加载文件到内存（特殊方法）-文件不能为空",false);
Assert.isNull(loadFileToMemoryReq.getLocalStorageRootPath(),"D2获取本地文件(公共)-M2从本地加载文件到内存（特殊方法）-本地存储根路径不能为空",false);
      loadFileToMemoryRes = nbResourceFile.loadFileFromLocal(loadFileToMemoryReq);




LoadLocalFileComRespDto retData = new LoadLocalFileComRespDto();





return retData;
  }
  //
}
